package com.qf.CompletableFuture;

import java.util.concurrent.*;

/**
 * 任务的串形化
 */
public class Demo04 {

    // 1.创建一个自己的线程池
    private static ThreadPoolExecutor executors = new ThreadPoolExecutor(
            5, // 核心线程池,线程池中至少有5个线程
            15, // 线程池中的最大线程数量
            3,  // 空闲线程回收的时间
            TimeUnit.SECONDS, // 时间单位
            new ArrayBlockingQueue(20), // 线程池中的线程已经最大了，剩下的引用压入队列等待空闲线程
            Executors.defaultThreadFactory(),  // 创建线程的默认工厂
            new ThreadPoolExecutor.AbortPolicy() // 拒绝策略，队列的长度满了以后执行的拒绝策略
    );

    public static void main(String[] args) throws ExecutionException, InterruptedException {

        // 1、任务1计算结果
        CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("任务1计算");
            return 10;
        }, executors);

        // 2.任务2开始计算
        CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(4000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("任务2计算");
            return 20;
        }, executors);


        // 3.任务2开始计算
        CompletableFuture<Integer> future3 = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("任务3计算");
            return 20;
        }, executors);


//        CompletableFuture<Void> future4 = CompletableFuture.allOf(future1, future2, future3);
        CompletableFuture<Object> future4 = CompletableFuture.anyOf(future1, future2, future3);
        future4.get(); // 阻塞
        System.out.println("3个任务已经执行完了");

    }
}

